from PyQt5.QtWidgets import QDialog, QTableView, QMessageBox, QHeaderView, QTableWidgetItem
from PyQt5.QtCore import Qt, QSortFilterProxyModel
from PyQt5.QtSql import QSqlTableModel
from PyQt5 import QtWidgets

from database.db_manager import DatabaseManager
from view.custom_dialog import AdvancedQueryDialog

# 导入由qdesigner生成的UI类
from ui.SelectDrillRodFromDbDialog import Ui_Dialog


def show_database_viewer(parent=None, jiekadalao_view=None):
    """显示数据库查看对话框的便捷函数
    
    Args:
        parent: 父窗口
        jiekadalao_view: JiekadalaoView实例，用于访问tableWidget_zzsj
    """
    dialog = DatabaseViewerDialog(parent, jiekadalao_view)
    dialog.exec_()


class DatabaseViewerDialog(QDialog, Ui_Dialog):
    """数据库查看对话框"""
    
    def __init__(self, parent=None, jiekadalao_view=None):
        # 确保parent是QWidget类型
        self.parent = parent
        self.jiekadalao_view = jiekadalao_view  # 保存JiekadalaoView实例引用
        parent_W = None
        if self.parent is not None and not isinstance(self.parent, QtWidgets.QWidget):
            # 如果传入的不是QWidget，尝试获取其parentWidget或使用None
            if hasattr(self.parent, 'parentWidget') and callable(self.parent.parentWidget):
                parent_W = self.parent.parentWidget()
        super().__init__(parent_W)
        self.setupUi(self)
        
        # 初始化数据库管理器
        self.db_manager = None
        
        # 当前查询条件
        self.current_query_conditions = []
        
        # 初始化UI
        self.init_ui()
        
        # 连接数据库
        self.connect_database()
    
    def init_ui(self):
        """初始化用户界面"""
        self.setWindowTitle("选择钻杆")
        
        # 连接信号
        self.Select_DbTable_comboBox.addItems(["wells", ])
        self.Select_DbTable_comboBox.currentIndexChanged.connect(self.on_table_changed)
        self.Select_DbTable_comboBox.setMinimumWidth(150)
        
        self.Search_lineEdit.textChanged.connect(self.on_search_text_changed)
        self.Search_lineEdit.setMinimumWidth(200)
        
        self.Advanced_Search_pushButton.clicked.connect(self.show_advanced_query)
        self.pushButton_sel.clicked.connect(self.on_select_button_clicked)
        self.pushButton_sel.setEnabled(False)  # 初始禁用
        
        # 设置表格视图
        self.DB_Show_tableView.setSelectionBehavior(QTableView.SelectRows)
        self.DB_Show_tableView.setSelectionMode(QTableView.ExtendedSelection)
        self.DB_Show_tableView.setSortingEnabled(True)
        # 修改列宽调整模式，允许用户手动调节列宽
        header = self.DB_Show_tableView.horizontalHeader()
        for i in range(header.count()):
            header.setSectionResizeMode(i, QHeaderView.Interactive)
        # 最后一列可以拉伸以填充剩余空间
        header.setStretchLastSection(True)
        self.DB_Show_tableView.setAlternatingRowColors(True)
        self.DB_Show_tableView.setShowGrid(True)
        self.DB_Show_tableView.setGridStyle(Qt.SolidLine)
        self.DB_Show_tableView.setEditTriggers(QTableView.NoEditTriggers)  # 禁止直接编辑
        self.DB_Show_tableView.verticalHeader().setVisible(False)  # 隐藏垂直表头（行号）
        
        # 设置表格双击事件
        self.DB_Show_tableView.doubleClicked.connect(self.on_table_double_clicked)
        
        # 初始化表格模型
        self.table_model = None
        self.search_proxy_model = QSortFilterProxyModel()
        self.search_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
        
        # 连接选择变更信号
        # 注意：selectionModel() 只有在设置模型后才存在，所以连接操作将在 load_table_data 中进行
        
        # 初始状态下禁用控件
        self.set_controls_enabled(False)
    
    def set_controls_enabled(self, enabled):
        """设置控件启用状态"""
        self.Select_DbTable_comboBox.setEnabled(enabled)
        self.Search_lineEdit.setEnabled(enabled)
        self.Advanced_Search_pushButton.setEnabled(enabled)
        # 先检查selectionModel是否存在，避免NoneType错误
        # 只有当恰好选中一行时才启用按钮
        has_single_selection = False
        if enabled and self.DB_Show_tableView.selectionModel():
            selected_rows = self.DB_Show_tableView.selectionModel().selectedRows()
            has_single_selection = len(selected_rows) == 1
        self.pushButton_sel.setEnabled(has_single_selection)
        self.DB_Show_tableView.setEnabled(enabled)
    
    def connect_database(self):
        """连接数据库"""
        if not self.db_manager:
            self.db_manager = DatabaseManager()
            
            # 连接信号
            self.db_manager.connection_established.connect(self.on_connection_established)
            self.db_manager.query_completed.connect(self.on_query_completed)
        
        # 尝试连接
        self.db_manager.connect()
    
    def on_connection_established(self, success, message):
        """数据库连接建立回调"""
        if success:
            self.set_controls_enabled(True)
            self.load_table_data()
        else:
            QMessageBox.warning(self, "连接错误", message)
            self.set_controls_enabled(False)
    
    def on_query_completed(self, success, message):
        """查询完成回调"""
        if not success:
            QMessageBox.warning(self, "查询错误", message)
    
    def load_table_data(self):
        """加载表格数据"""
        if not self.db_manager or not self.db_manager.connected:
            return
            
        # 获取当前选择的表名
        table_name = self.Select_DbTable_comboBox.currentText()
        
        # 创建表格模型
        self.table_model = QSqlTableModel(self, self.db_manager.qt_db)
        self.table_model.setTable(table_name)
        self.table_model.setEditStrategy(QSqlTableModel.OnManualSubmit)
        self.table_model.select()
        
        # 设置搜索代理模型
        self.search_proxy_model.setSourceModel(self.table_model)
        
        # 将搜索代理模型设置到表格视图上
        self.DB_Show_tableView.setModel(self.search_proxy_model)
        
        # 确保在表格视图有模型后再连接选择变更信号
        if self.DB_Show_tableView.selectionModel():
            # 先断开旧的连接（如果存在）
            try:
                self.DB_Show_tableView.selectionModel().selectionChanged.disconnect(self.on_selection_changed)
            except (TypeError, RuntimeError):
                pass  # 如果没有连接存在，忽略错误
            # 连接新的信号
            self.DB_Show_tableView.selectionModel().selectionChanged.connect(self.on_selection_changed)
            # 初始设置选择按钮状态
            self.pushButton_sel.setEnabled(False)

    
    def on_table_changed(self):
        """表格选择变更处理"""
        self.load_table_data()
    
    def on_search_text_changed(self, text):
        """搜索文本变更处理"""
        self.search_proxy_model.setFilterFixedString(text)
        self.search_proxy_model.setFilterKeyColumn(-1)  # 搜索所有列
    
    def on_selection_changed(self, selected, deselected):
        """表格选择变更处理"""
        # 只有在选中恰好一行时才启用选择按钮
        if self.DB_Show_tableView.selectionModel():
            selected_rows = self.DB_Show_tableView.selectionModel().selectedRows()
            # 只有当恰好选中一行时才启用按钮
            has_single_selection = len(selected_rows) == 1
            self.pushButton_sel.setEnabled(has_single_selection)
    
    def on_select_button_clicked(self):
        """选择按钮点击处理"""
        # 获取选中的行
        selected_rows = self.DB_Show_tableView.selectionModel().selectedRows()
        if selected_rows:
            # 如果有多行选中，只处理第一行
            index = selected_rows[0]
            self._print_row_data(index)
    
    def on_table_double_clicked(self, index):
        """表格双击处理"""
        self._print_row_data(index)
    
    def _print_row_data(self, index):
        """将选中的行数据写入到tableWidget_zzsj表格中"""
        if not self.jiekadalao_view:
            QMessageBox.warning(self, "错误", "无法访问主窗口表格")
            return
            
        # 获取选中行的数据
        source_index = self.search_proxy_model.mapToSource(index)
        row = source_index.row()
        
        # 获取表格的所有列名
        headers = []
        for col in range(self.table_model.columnCount()):
            headers.append(self.table_model.headerData(col, Qt.Horizontal))
        
        # 获取选中行的数据
        row_data = {}
        for col in range(self.table_model.columnCount()):
            value = self.table_model.data(self.table_model.index(row, col))
            if value is not None:
                row_data[headers[col]] = str(value)
        
        # 访问tableWidget_zzsj
        table_widget = self.jiekadalao_view.ui.tableWidget_zzsj
        
        # 获取当前表格中的数据行数（不包括表头）
        current_row_count = table_widget.rowCount()
        
        # 首先检查公称直径是否包含"钻铤"
        nominal_diameter = row_data.get("公称直径", "")
        if "钻铤" in nominal_diameter:
            drill_name = "钻铤"
        else:
            # 根据当前数据量确定钻杆名称
            if current_row_count == 0:
                QMessageBox.warning(self, "提示", "请先选择钻铤")
                return
            else:
                drill_name = f"第{current_row_count}段钻杆"
        
        # 插入新行
        row_position = current_row_count
        table_widget.insertRow(row_position)
        
        # 设置"钻杆名称"列（第2列，索引为1）
        table_widget.setItem(row_position, 0, QTableWidgetItem(drill_name))
        
        # 获取tableWidget_zzsj的列名
        table_headers = []
        for col in range(table_widget.columnCount()):
            header_item = table_widget.horizontalHeaderItem(col)
            if header_item:
                table_headers.append(header_item.text())
        
        # 从第3列开始（索引为2），跳过"自"和"从"列，填充wells表的数据
        data_col_index = 0  # wells表数据列的索引
        for col in range(3, table_widget.columnCount()):  # 从第3列开始
            if data_col_index < len(headers):
                header_name = headers[data_col_index]
                value = row_data.get(header_name, "")
                table_widget.setItem(row_position, col, QTableWidgetItem(value))
                data_col_index += 1
        
        self.accept()
    
    def show_advanced_query(self):
        """显示高级查询对话框"""
        if not self.db_manager or not self.db_manager.connected:
            return
            
        # 获取当前表的列名
        column_names = []
        for i in range(self.table_model.columnCount()):
            column_names.append(self.table_model.headerData(i, Qt.Horizontal))
        
        # 创建高级查询对话框，传入当前已有的查询条件
        dialog = AdvancedQueryDialog(column_names, self, initial_conditions=self.current_query_conditions)
        if dialog.exec_() == QDialog.Accepted:
            # 获取查询条件
            conditions = dialog.get_query_conditions()
            self._apply_advanced_query(conditions)
    
    def _apply_advanced_query(self, conditions):
        """应用高级查询"""
        if not conditions:
            # 清除当前条件
            self.current_query_conditions = []
            # 清除过滤器
            self.table_model.setFilter("")
            self.table_model.select()
            return
            
        # 保存当前查询条件，以便后续恢复
        self.current_query_conditions = conditions.copy()
            
        # 构建查询字符串
        where_clauses = []
        logic_operators = []
        
        for i, cond in enumerate(conditions):
            # 处理条件格式
            if len(cond) == 4:  # 新格式: (逻辑关系, 列名, 操作符, 值)
                logic, column, operator, value = cond
                if i > 0:  # 第一个条件不需要逻辑关系
                    logic_operators.append(logic)
            else:  # 旧格式: (列名, 操作符, 值)
                column, operator, value = cond
                if i > 0:  # 第一个条件不需要逻辑关系
                    logic_operators.append("AND")  # 默认AND关系
            
            # 获取列索引
            column_index = -1
            for j in range(self.table_model.columnCount()):
                if self.table_model.headerData(j, Qt.Horizontal) == column:
                    column_index = j
                    break
            
            if column_index >= 0:
                # 获取实际的列名
                real_column = self.table_model.record().fieldName(column_index)
                
                # 获取字段类型
                field = self.table_model.record().field(column_index)
                is_numeric = field.type() in [2, 3, 4, 6]  # 整数和浮点数类型
                
                # 处理不同的操作符，并根据字段类型正确处理值
                try:
                    if operator == "包含":
                        where_clauses.append(f"{real_column} LIKE '%{value}%'")
                    elif operator == "等于":
                        if is_numeric and value.strip():
                            where_clauses.append(f"{real_column} = {float(value)}")
                        else:
                            where_clauses.append(f"{real_column} = '{value}'")
                    elif operator == "大于":
                        if is_numeric and value.strip():
                            where_clauses.append(f"{real_column} > {float(value)}")
                        else:
                            where_clauses.append(f"{real_column} > '{value}'")
                    elif operator == "小于":
                        if is_numeric and value.strip():
                            where_clauses.append(f"{real_column} < {float(value)}")
                        else:
                            where_clauses.append(f"{real_column} < '{value}'")
                    elif operator == "大于等于":
                        if is_numeric and value.strip():
                            where_clauses.append(f"{real_column} >= {float(value)}")
                        else:
                            where_clauses.append(f"{real_column} >= '{value}'")
                    elif operator == "小于等于":
                        if is_numeric and value.strip():
                            where_clauses.append(f"{real_column} <= {float(value)}")
                        else:
                            where_clauses.append(f"{real_column} <= '{value}'")
                except ValueError:
                    # 如果数值转换失败，使用字符串比较
                    if operator == "等于":
                        where_clauses.append(f"{real_column} = '{value}'")
                    elif operator in ["大于", "小于", "大于等于", "小于等于"]:
                        # 对于非数值字段，这些比较可能没有意义，但仍然执行
                        op_map = {"大于": ">", "小于": "<", "大于等于": ">=", "小于等于": "<="}
                        where_clauses.append(f"{real_column} {op_map[operator]} '{value}'")
        
        # 组合条件，应用用户选择的逻辑关系
        if where_clauses:
            if len(where_clauses) == 1:
                filter_str = where_clauses[0]
            else:
                filter_str = where_clauses[0]
                for i, clause in enumerate(where_clauses[1:], 1):
                    if i <= len(logic_operators):
                        operator = logic_operators[i-1]
                        filter_str += f" {operator} {clause}"
            
            # 设置过滤器
            self.table_model.setFilter(filter_str)
            self.table_model.select()
            
            # 检查是否有结果
            if self.table_model.rowCount() == 0:
                QMessageBox.information(self, "查询结果", "没有找到匹配的记录")
        else:
            # 清除当前条件
            self.current_query_conditions = []
            # 清除过滤器
            self.table_model.setFilter("")
            self.table_model.select()